/*
 * gl
 */

/**
 * 解析心跳数据 √
 * @param {String[]} arr 心跳数据
 * @returns obj 设备数据
 * @returns {string} obj.datetime_work 设备数据
 * @returns {string} obj.datetime_work1 设备数据
 * @returns {number} obj.tork 设备数据
 * @returns {number} obj.max_tork 设备数据
 * @returns {number} obj.angle 设备数据
 */
function formatDeviceData(arr) {
  const strRes = cmd.hexArrayToCharArray(arr)
  console.log(strRes)
  const res = {
    measValue: strRes,
  }
  return res
}
const cmd = {
  hexArrayToCharArray: (hexArray) => {
    return hexArray.map((hex) => String.fromCharCode(parseInt(hex, 16)))
  },
  // 将16进制字符串数组转换为普通字符串
  hexArrayToString: (hexArray) => {
    // 将每个16进制字符串转换为数字，再转换为字符
    return hexArray.map((hex) => String.fromCharCode(parseInt(hex, 16))).join('')
  },
  //二进制bi数据转换成字符数组
  ab2char: (buffer) => {
    var charArr = Array.prototype.map.call(new Uint8Array(buffer), function (bit) {
      return '' + String.fromCharCode(bit)
    })
    // console.log('charArr: ', charArr)
    return charArr
  },
  //二进制bit数据转换成十六进制数组
  ab2hex: (buffer) => {
    var hexArr = Array.prototype.map.call(new Uint8Array(buffer), function (bit) {
      return ('00' + bit.toString(16)).slice(-2)
    })
    // console.log('ab2hex: ', hexArr)
    return hexArr
  },
  str2Hex: (str) => {
    let hex = ''
    for (let i = 0; i < str.length; i++) {
      // 获取字符的Unicode编码
      const charCode = str.charCodeAt(i)

      // 将编码转换为十六进制，并确保两位表示
      const hexValue = charCode.toString(16)

      // 拼接到结果字符串
      hex += hexValue.padStart(2, '0')
      //字符串十六进制数组
    }
    return hex
  },
  str2HexArr: (str) => {
    let hex = ''
    let arr = []
    for (let i = 0; i < str.length; i++) {
      // 获取字符的Unicode编码
      const charCode = str.charCodeAt(i)
      // 将编码转换为十六进制，并确保两位表示
      const hexValue = charCode.toString(16)
      // 拼接到结果字符串
      hex = hexValue.padStart(2, '0')
      //字符串十六进制数组
      arr.push(hex)
    }
    return arr
  },
  hex2Str: (hex) => {
    let str = ''
    for (let i = 0; i < hex.length; i += 2) {
      // 提取两个十六进制位
      const hexValue = hex.substr(i, 2)

      // 将十六进制转换为字符编码
      const charCode = parseInt(hexValue, 16)

      // 将字符编码转换为字符并拼接
      str += String.fromCharCode(charCode)
    }
    return str
  },
  // 格式化值 将16进制的数,低位放高位，设置指令时是：XL XH
  xhxl2xlxh: (n) => {
    let hex = n.length % 2 ? '0' + n : n
    return hex
      .split(/(.{2})/g)
      .filter((v) => v)
      .reverse()
  },
  // CRC-16/MODBUS 校验
  crc16modbus: (data) => {
    const dataBytes = data.map((v) => parseInt(v, 16))

    let crc = 0xffff
    const polynomial = 0xa001 // This is the polynomial x^16 + x^15 + x^2 + 1

    for (const byte of dataBytes) {
      crc ^= byte
      for (let i = 0; i < 8; i++) {
        if (crc & 0x0001) {
          crc = ((crc >> 1) ^ polynomial) & 0xffff
        } else {
          crc >>= 1
        }
      }
    }
    return crc.toString(16).toUpperCase().padStart(4, '0').match(/\w{2}/g).reverse()
  },
  //将指令的数组格式转换成buffer
  arrayToBuffer: (arr) => {
    let cmd = arr.map((v) => '0x' + v)
    // console.log("arrayToBuffer", cmd)
    let uint16arr = new Uint8Array(cmd)
    return uint16arr.buffer //返回由 Uint8Array引用的 ArrayBuffer
  },
}

export default {
  // cmd: {
  //   setCmd,
  //   getCmd,
  //   // getInitReadCmd,
  //   setModeCmd,
  //   getSendDataCmd,
  //   getSendOrderBatchCmd,
  // },
  // readDeviceCriticalValue,
  formatDeviceData,
}
